home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / Games / flying-6.11 / xmover.h < prev    next >
Encoding:
C/C++ Source or Header  |  1995-06-30  |  5.3 KB  |  186 lines
  1. #ifndef _xmover_h
  2. #define _xmover_h
  3.  
  4.  
  5. class BallMover {
  6.     public:
  7.         BallMover( const Real &r );
  8.         virtual ~BallMover();
  9.  
  10.         Real GetActRadius()        { return d/w2n/2; }
  11.  
  12.         virtual void Init();
  13.         virtual void DrawBallAt( int x, int y, int col_x );
  14.         virtual void MoveBallOnScreen( int oldx, int oldy, int newx, int newy, int col_x );
  15.         virtual Pixmap    GetShadowMap( int x, int y );
  16.  
  17. #ifdef STATISTICS
  18.         static unsigned long    moves;
  19. #endif
  20.  
  21.     protected:
  22.         int    r;                // Radius (in Pixeln)
  23.         int    d;                // Durchmesser (gleich 2mal Radius)
  24.  
  25.         double    max_rad;    // maximaler Radius, damit Pixel zur Kugel geh÷rt
  26.         double    max_rad2;// Quadrat des maximalen Radius
  27.         Pixmap    bpix;        // Bitmap der Balldarstellung
  28.         int        d_help;    // Gr÷▀e der Hintergrund-Pixmap (mind. (2*d-1))
  29.         Pixmap    help;        // Hintergrund-Pixmap
  30.  
  31.  
  32. friend class BallState;
  33. };
  34.  
  35.  
  36. class DiscMover : public BallMover {
  37.     public:
  38.         DiscMover( const Real &r );
  39.         virtual ~DiscMover();
  40.  
  41.         virtual void Init();
  42.         virtual Pixmap    GetShadowMap( int x, int y );
  43.  
  44.     protected:
  45.         Pixmap    lpix;    // Bitmap des Highlights
  46. };
  47.  
  48.  
  49. class ShadedBallMover : public BallMover {
  50.     public:
  51.         ShadedBallMover( const Real &r );
  52.         virtual ~ShadedBallMover();
  53.  
  54.         virtual void Init();
  55.  
  56.         void CreateLightWindow();
  57.         virtual Pixmap    GetShadowMap( int x, int y );
  58.  
  59.     protected:
  60.         Pixmap    *lpix;    // Bitmap-Feld der Highlights
  61.  
  62.         int    distx, disty;            // Rastergr÷▀e fⁿr Bereich der Highlights
  63.         int    lpixs_x, lpixs_y, lpixs_all;        // Zahl der Highlights
  64. };
  65.  
  66. #if (0)
  67. //
  68. // ------------------------------------------------------------------------
  69. //                      mult=6
  70.     Szenario:  rpixs_l=18  => vecs_l=108
  71.  
  72.     Polarkoordinaten     0    10    20    30                 ^
  73.                                 |     |     |     |          ltoRad | | Radtol
  74.                                                                       btoRad | | Radtob
  75.     Vektor-Ids           0     6     12    18                  v
  76.                         |.....|.....|.....|.....|.....|           <----St2AngVec
  77.                                                                                     /-St2AngPix
  78.     Pixmaps-Ids       |  0  |  1  |  2  |  3  |              <-/
  79.  
  80.     Polarkoordinaten      170   180   190                 170   180   190
  81.                                 |     |     |         +mult2    |     |     |
  82.     Vektor-Ids           102   108   114           102   108   114
  83.                         |.....|.....|.....|.....|  =>   |.....|.....|.....|
  84.     Pixmaps-Ids       |  17 |  0  |  1  |          |  17 |  0  |  1  |
  85. //
  86. // ------------------------------------------------------------------------
  87. //
  88. #endif
  89.  
  90. typedef unsigned int RingState;
  91.  
  92.  
  93. class HalfBallMover : public ShadedBallMover {
  94.     public:
  95.         HalfBallMover( const Real &r, int mode_in=1 );
  96.         virtual ~HalfBallMover();
  97.  
  98.         virtual void Init();
  99.  
  100.         void CreateRingWindow();
  101.         void CreateTurnWindow();
  102.  
  103.         Real    lToRad( int l )        {return (l-mult2)*M_PI*2.0/sym/(double)vecs_l;}
  104.         Real    bToRad( int b )        {return (b-mult2)*M_PI/(double)vecs_b;}
  105.         Real    lToDeg( int l )        {return (l-mult2)*360.0/sym/(double)vecs_l;}
  106.         Real    bToDeg( int b )        {return (b-mult2)*180.0/(double)vecs_b;}
  107.         int    RadTol( const Real &l )    {return (rtoi(l*(double)vecs_l/M_PI/2.0*sym)+mult2)%(vecs_l*(int)sym);}
  108.         int    RadTob( const Real &b )    {return (rtoi(b*(double)vecs_b/M_PI)+mult2)%vecs_b;}
  109.         int    DegTol( const Real &l )    {return (rtoi(l*(double)vecs_l/360.0*sym)+mult2)%(vecs_l*(int)sym);}
  110.         int    DegTob( const Real &b )    {return (rtoi(b*(double)vecs_b/180.0)+mult2)%vecs_b;}
  111.  
  112. #if (0)
  113.         Real    lVecToDeg( const Real &l )    {    return l*360.0/sym/rpixs_l/mult;    }
  114.         Real    bVecToDeg( const Real &b )    {    return b*180.0/rpixs_b/mult;    }
  115.  
  116.         RingState GetStateForDeg( Real l, Real b ) {
  117.         void StateToAngleDeg( RingState st, Real *l, Real *b ) {
  118.             *l = (st/rpixs_b)*360.0/rpixs_l;
  119.             *b = (st%rpixs_b)*180.0/rpixs_b;
  120.         }
  121. #endif
  122.  
  123.         RingState AngVec2St( int l, int b ) { return (l*vecs_b+b)%vecs_all;    }
  124.         RingState AngVec2StBnd( int l, int b ) {
  125.                 if ( sym>1.0 && l>=vecs_l ) { l-=vecs_l; b=(vecs_b-b+mult)%vecs_b; }
  126.                 return AngVec2St( l, b );
  127.         }
  128.             
  129.         RingState AngPix2St( int l, int b ) { return AngVec2St(l*mult+mult2,b*mult+mult2); }
  130.         RingState AngRad2St( const Real &l, const Real &b ) {
  131.                 return AngVec2StBnd(RadTol(l),RadTob(b));
  132.         }
  133.  
  134.         void St2AngVec( RingState st, int *l, int *b ) {
  135.             *l = st/vecs_b;
  136.             *b = st%vecs_b;
  137.         }
  138.         void St2AngPix( RingState st, int *l, int *b ) {
  139.             St2AngVec(st,l,b);
  140.         /*    *l += mult2; */    *l /= mult;
  141.         /*    *b += mult2; */    *b /= mult;
  142.         }
  143.         int PixIndex( int l, int b )    {                /* l,b in PixSystem */
  144.             return (l*rpixs_b+b)%rpixs_all;
  145.         }
  146.         int PixIndex( RingState st ) {
  147.             int    l,b;
  148.             St2AngPix( st, &l, &b );
  149.             return l*rpixs_b+b;
  150.         }
  151.  
  152.         RingState Turn( RingState ost, int dx, int dy );
  153.  
  154.         void RollBallAt( int x, int y, RingState st, int col_x );
  155.         void RollBallOnScreen( int oldx, int oldy, RingState ost,
  156.                                       int newx, int newy, RingState *nst, int col_x );
  157.     protected:
  158.         Pixmap        *rpix;        // Bitmap-Feld der Ringe
  159.  
  160.         RingState    *right;        // Felder zur Verkettung der RingState's
  161.         RingState    *left;
  162.         RingState    *up;
  163.         RingState    *down;
  164.  
  165.         Real    sym;        // bei Symetrie nicht alle muessen nicht fuer alle
  166.                             // Winkel die Kugeln berechnet werden.
  167.         int    mult;        // Zahl der gespeicherten Zwischenschritte
  168.         int    mult2;    // Zwischenschritte / 2
  169.         int    vecs_l, vecs_b, vecs_all;            // Zahl der Hilfs-Vektoren
  170.         int    rpixs_l, rpixs_b, rpixs_all;    // Zahl der Ring-Pixmaps
  171.  
  172.         int    mode;                    // Halbkugel / Vollkugel mit Punkt
  173.  
  174.         static const int o;        // Offset im Trace-Fenster
  175.         Window        tw;            // Trace-Fenster
  176.         Pixmap        nbpix;
  177.  
  178. friend class HalfBallState;
  179. #ifdef DEBUG
  180.     friend class TestField;
  181. #endif
  182. };
  183.  
  184.  
  185. #endif
  186.